MySQL模式下dbcp连接池配置依赖/配置文件和示例代码_云数据库 OceanBase 版(OceanBase)-阿里云帮助中心

本文将介绍如何使用 DBCP 连接池、MySQL Connector/J 和 OceanBase 数据库构建一个应用程序，实现基本的数据库操作，包括创建表、插入、删除、更新和查询数据等。

点击下载 dbcp-mysql-client 示例工程

前提条件

您已安装 OceanBase 数据库并且创建了 MySQL 模式租户。
您已安装 JDK 1.8 和 Maven。
您已安装 Eclipse。
说明
本文档运行代码使用的工具是 Eclipse IDE for Java Developers 2022-03 版本，您也可以根据个人喜好选择适合自己的工具运行的示例代码。

操作步骤

说明

本文中给出的操作步骤是在 Windows 环境下使用 Eclipse IDE for Java Developers 2022-03 编译和运行该项目的步骤。如果您使用的是其他操作系统环境或编译器，那么操作步骤可能会略有不同。

将dbcp-mysql-client项目导入到 Eclipse 中。
获取 OceanBase 数据库 URL。
修改dbcp-mysql-client项目中的数据库连接信息。
运行dbcp-mysql-client项目。

步骤一：将 dbcp-mysql-client 项目导入到 Eclipse 中

打开 Eclipse，在菜单栏上选择 File->Open Projects from File System。
在弹出的对话框中，点击 Directory 按钮选择项目所在的目录，然后点击 Finish 完成导入。
说明
当使用 Eclipse 导入 Maven 项目时，Eclipse 会自动检测项目中的pom.xml文件，并根据文件中描述的依赖关系自动下载所需的依赖库，并将它们添加到项目中。
查看项目情况。

步骤二：获取 OceanBase 数据库 URL

联系 OceanBase 数据库部署人员或者管理员获取相应的数据库连接串。
示例如下：
```
obclient -hxxx.xxx.xxx.xxx -P3306 -utest_user001 -p****** -Dtest
```
更多连接串的信息，请参见获取连接参数。
根据 OceanBase 数据库连接串信息填写下面 URL 的对应信息。
```
jdbc:mysql://$host:$port/$database_name?user=$user_name&password=$password
```
参数说明：
- $host：OceanBase 数据库连接的域名。
- $port：OceanBase 数据库连接端口，MySQL 模式租户默认是 3306。
- $database_name：需要访问的数据库名称。
- $user_name：租户的连接账号。
- $password：提供账户密码。
更多有关 MySQL Connector/J 连接属性信息，请参见 Configuration Properties。
示例如下：
```
jdbc:mysql://xxx.xxx.xxx.xxx:3306/test?user=test_user001&password=******
```

步骤三：修改 dbcp-mysql-client 项目中的数据库连接信息

根据 步骤二：获取 OceanBase 数据库 URL 中获取的信息修改文件dbcp-mysql-client/src/main/resources/db.properties中的数据库连接信息。

示例如下：

OBServer 节点的 IP 地址为xxx.xxx.xxx.xxx。
访问端口使用的是 3306。
需要访问的数据库名称为test。
租户的连接账户是test_user001。
密码是******。

代码如下：

...
url=jdbc:mysql://xxx.xxx.xxx.xxx:3306/test
username=test_user001
password=******
...

步骤四：运行 dbcp-mysql-client 项目

在项目导航器视图中，找到并展开 src/main/java 目录。
右键点击 Main.java 文件，然后选择 Run As->Java Application。
在 Eclipse 的控制台窗口中来查看项目的日志信息和输出结果。

也可以在 OceanBase 客户端（OBClient）中执行以下 SQL 语句查看结果。

obclient [test]> SELECT * FROM test_tbl1;

返回结果如下：

+------+--------------+
| id   | name         |
+------+--------------+
|    5 | test_update  |
|    6 | test_insert6 |
|    7 | test_insert7 |
|    8 | test_insert8 |
|    9 | test_insert9 |
+------+--------------+
5 rows in set

项目代码介绍

点击 dbcp-mysql-client 下载项目代码，是一个名称为dbcp-mysql-client.zip的压缩包。

解压后，得到一个名为dbcp-mysql-client的文件夹。目录结构如下所示：

dbcp-mysql-client
├── src
│   └── main
│       ├── java
│       │   └── com
│       │       └── example
│       │           └── Main.java
│       └── resources
│           └── db.properties
└── pom.xml

文件说明：

src：源代码根目录。
main：主代码目录，包含应用程序的主要逻辑。
java：Java 源代码目录。
com：Java 包目录。
example：示例项目的包目录。
Main.java：主类程序示例文件，包含创建表、插入、删除、更新和查询数据等逻辑。
resources：资源文件目录，包含配置文件等。
db.properties：连接池的配置文件，包含了数据库连接的相关参数。
pom.xml：Maven 项目的配置文件，用于管理项目的依赖和构建设置。

pom.xml 代码介绍

pom.xml文件是 Maven 项目的配置文件，定义了项目的依赖项、插件和构建规则等信息。Maven 是一个 Java 项目管理工具，可以自动下载依赖项、编译和打包项目等操作。

本文pom.xml文件的代码主要包括以下几个部分：

文件声明语句。
声明本文件是一个 XML 文件，使用的 XML 版本是1.0，字符编码方式是UTF-8。
代码如下：
```
<?xml version="1.0" encoding="UTF-8"?>
```
配置 POM 的命名空间和 POM 模型版本。
1. 通过xmlns指定 POM 的命名空间为http://maven.apache.org/POM/4.0.0。
2. 通过xmlns:xsi指定 XML 命名空间http://www.w3.org/2001/XMLSchema-instance。
3. 通过xsi:schemaLocation指定 POM 的命名空间为http://maven.apache.org/POM/4.0.0和 POM 的 XSD 文件的位置为http://maven.apache.org/xsd/maven-4.0.0.xsd。
4. 通过<modelVersion>元素指定了该 POM 文件使用的 POM 模型版本为4.0.0。
代码如下：
```
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

 

</project>
```
配置基本信息。
1. 通过<groupId>指定项目所属组织为com.example。
2. 通过<artifactId>指定项目的名称为dbcp-mysql-client。
3. 通过<version>项目的版本号为1.0-SNAPSHOT。
代码如下：
```
    <groupId>com.example</groupId>
    <artifactId>dbcp-mysql-client</artifactId>
    <version>1.0-SNAPSHOT</version>
```
配置项目源文件的属性。
指定 Maven 的编译器插件为maven-compiler-plugin，并设置了源代码和目标 Java 版本都为 8。这意味着项目的源代码使用 Java 8 特性编写，且编译后的字节码也将兼容 Java 8 运行时环境。这样设置可以确保项目在编译和运行时能够正确地处理 Java 8 的语法和特性。
说明
Java 1.8 和 Java 8 是同一个版本的不同命名方式。
代码如下：
```
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
```
配置项目所依赖组件。
通过<dependency>定义依赖项：
- MySQL JDBC 依赖项：
  1. 通过<groupId>指定依赖项所属的组织为mysql。
  2. 通过<artifactId>指定依赖项的名称为mysql-connector-java。
  3. 通过<version>指定依赖项的版本号为5.1.47。
- dbcp 依赖项：
  1. 通过<groupId>指定依赖项所属的组织为org.apache.commons。
  2. 通过<artifactId>指定依赖项的名称为commons-dbcp2。
  3. 通过<version>指定依赖项的版本号为2.9.0。
代码如下：
```
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>
```

db.properties 代码介绍

db.properties是本文示例的连接池配置文件，其中包含了连接池的配置属性。这些属性包括驱动程序的类名、数据库URL、用户名、密码、连接池的大小和限制、连接的超时时间以及处理被遗弃连接的选项。

本文db.properties文件的代码主要包括以下几个部分：

配置数据库连接参数。
1. 设置驱动程序的类名，这里是 MySQL JDBC 驱动的类名com.mysql.jdbc.Driver。
2. 设置数据库连接的 URL，包括主机 IP、端口号、需要访问的数据库等信息。
3. 设置数据库用户名。
4. 设置数据库密码。
5. 设置连接属性，其中useSSL=false表示不使用 SSL 加密连接，characterEncoding=UTF-8表示使用 UTF-8 编码进行数据传输。
代码如下：
```
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://$host:$port/$database_name
username=$user_name
password=$password
connectionProperties=useSSL=false;characterEncoding=UTF-8
```
参数解释：
- $host：OceanBase 数据库连接的域名。
- $port：OceanBase 数据库连接端口，MySQL 模式租户默认是 3306。
- $database_name：需要访问的数据库名称。
- $user_name：租户的连接账号。
- $password：提供账户密码。
配置其他 DBCP 连接池的参数。
1. 设置连接池的初始大小为30，即连接池中最初要创建的连接数。
2. 设置连接池的最大连接数为30，即连接池中允许存在的最大连接数。
3. 设置连接池中允许保持空闲状态的最大连接数为10。
4. 设置连接池中保持空闲状态的最小连接数为5。如果空闲连接数低于此值，连接池将创建新的连接。
5. 设置从连接池获取连接时的最大等待时间（以毫秒为单位）为1000。如果连接池中的所有连接都被占用，并且没有可用的连接，获取连接的操作将会等待，直到有可用的连接或超过最大等待时间。
6. 删除放弃的连接之前的超时时间（单位为秒）为1。
  说明
  removeAbandonedTimeout的默认值为 300 秒，本示例中是为了测试程序才配置为 1 秒。您可以根据实际情况适当调整该值以满足应用程序的需求。
7. 程序中的连接不使用后是否被连接池回收：
  - 设置是否在维护过程中检测并清除被遗弃的连接，设置为true。
  - 设置是否在从连接池借用连接时检测并清除被遗弃的连接，设置为true。
代码如下：
```
initialSize=30
maxTotal=30
maxIdle=10
minIdle=5
maxWaitMillis=1000
removeAbandonedTimeout=1

removeAbandonedOnMaintenance=true
removeAbandonedOnBorrow=true
```

重要

具体的属性（参数）配置取决于项目需求和数据库的特点，建议您根据实际情况进行调整和配置。更多 DBCP 连接池参数的信息，请参见 BasicDataSource Configuration Parameters。

DBCP 连接池基本数据源配置参数：

分类	属性	缺省值	描述
必选参数	driverClass	N/A	指定数据库驱动程序的类名。
	url	N/A	指定连接数据库时使用的 URL。
	username	N/A	指定连接数据库时使用的用户名。
	password	N/A	指定连接数据库时使用的密码。
建议设置的参数	initialSize	0	指定连接池的初始大小，即连接池启动时创建的初始连接数。如果将其设置为大于 0 的值，则在连接池初始化时会创建指定数量的连接。这可以提前创建连接并减少客户端第一次请求连接时的延迟。
	maxTotal	8	指定连接池的最大连接数，即连接池中允许存在的最大连接数。如果将其设置为负数，表示没有限制。
	maxIdle	8	指定在不释放额外连接的情况下，连接池中允许保持空闲状态的最大连接数。如果将其设置为负数，表示没有限制。
	minIdle	0	指定在不释放额外连接的情况下，连接池中保持空闲状态的最小连接数。如果将其设置为负数，表示没有限制。
	maxWaitMillis	indefinitely	指定从连接池获取连接时的最大等待时间（以毫秒为单位）。设置为 -1，表示无限等待。如果设置为一个正数，当连接池中的连接都被占用时，等待获取连接的操作将会等待指定的时间，超过时间后将会抛出异常。
	validationQuery	N/A	指定用于验证连接是否有效的 SQL 查询语句。如果指定，此查询必须是至少返回一行的`SQL SELECT`语句。如果未指定，连接将通过调用`isValid()`方法进行验证。
	testOnBorrow	true	指定在从连接池借用对象时是否进行验证。如果对象无法验证，它将从连接池中删除，将尝试借用另一个对象。
	testWhileIdle	false	指定连接池是否在空闲时进行验证。如果设置为`true`，连接池将定期执行验证查询来检查空闲连接的有效性。如果对象未能通过验证，它将从连接池中删除。
可选参数	connectionProperties	N/A	指定以键值对形式的额外连接属性，这些属性将在获取数据库连接时传递给底层的 JDBC驱动程序。字符串的格式必须是`propertyName=property;` 重要 `username`和`password`属性将被明确传递，因此不需要在此处包含它们。
可选参数	removeAbandonedOnMaintenance removeAbandonedOnBorrow	false	这两个参数用于控制在连接被认为是被遗弃的情况下的移除行为。 `removeAbandonedOnMaintenance`：如果将此参数设置为`true`，连接池会在维护循环（当驱逐结束时）中移除被认为是被遗弃的连接。但是，此参数只在启用维护循环（通过设置`timeBetweenEvictionRunsMillis`为正值）时才会生效。 `removeAbandonedOnBorrow`：如果将此参数设置为`true`，在每次从连接池中借用连接时，连接池会检查是否存在被认为是被遗弃的连接，并将其移除。此外，移除操作还需要满足以下两个条件： `getNumActive() > getMaxTotal() - 3`：当前活动连接数大于最大连接数减去 3。 `getNumIdle() < 2`：当前空闲连接数小于 2。通过设置以上两个参数为`true`，连接池可以自动检测和移除被遗弃的连接。被遗弃的连接是指长时间未被使用的连接，可能是由于应用程序没有正确关闭连接而导致的。通过移除这些被遗弃的连接，可以释放数据库资源并提高连接池的性能和效率。

Main.java 代码介绍

Main.java文件是示例程序的一部分，用于演示通过 DBCP 连接池获取数据库连接，并执行一系列数据库操作，包括创建表、插入数据、删除数据、更新数据、查询数据，并将查询结果打印出来。

本文Main.java文件的代码主要包括以下几个部分：

导入所需的类和接口。
导入所需的类和接口，其中包括了用于读取文件、数据库操作和数据库连接池的相关类和接口。这些类和接口在后续的代码中会被使用到。
1. 声明一个名为com.example的包，该包用于存放当前 Java 类。
2. 导入java.io.FileInputStream类，用于读取文件。
3. 导入java.sql.Connection接口，表示与数据库的连接。
4. 导入java.sql.PreparedStatement接口，表示预编译的 SQL 语句。
5. 导入java.sql.ResultSet接口，表示数据库查询的结果集。
6. 导入java.sql.SQLException异常类，表示 SQL 操作异常。
7. 导入java.util.Properties类，用于加载配置文件。
8. 导入org.apache.commons.dbcp2.BasicDataSource类，表示数据库连接池。
9. 导入org.apache.commons.dbcp2.BasicDataSourceFactory类，用于创建数据库连接池。
代码如下：
```
package com.example;

import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
```

定义类名和方法。

创建 Main 类，并定义了一个main方法作为程序的入口点。
在main方法中，首先调用createDataSource()方法创建连接池对象dataSource。
使用try-with-resources语句，在连接池对象的生命周期结束时自动关闭资源。
在try代码块中，调用getConnection()方法从连接池中获取一个数据库连接对象conn。
依次调用createTable()、insertData()、deleteData()、updateData()和queryData()方法，执行相应的数据库操作。
在发生异常时，通过catch块打印异常信息。

代码如下：

public class Main {

    public static void main(String[] args) {
        try (BasicDataSource dataSource = createDataSource()) {
            try (Connection conn = dataSource.getConnection()) {
                createTable(conn);
                insertData(conn);
                deleteData(conn);
                updateData(conn);
                queryData(conn);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 创建连接池
    // 定义用于创建表的方法
    // 定义用于插入数据的方法
    // 定义用于删除数据的方法
    // 定义用于更新数据的方法
    // 定义用于查询数据的方法
}

创建连接池。
提供一个方便创建数据库连接池的方法，通过读取配置文件中的参数来初始化连接池对象。具体步骤如下：
1. 定义一个私有静态方法createDataSource()，返回类型为BasicDataSource。方法可能会抛出Exception异常。
2. 创建一个Properties对象props，用于存储数据库连接的配置信息。
3. 创建一个FileInputStream对象is，用于读取位于src/main/resources目录下的db.properties文件。
4. 通过load()方法，将db.properties文件中的键值对加载到 props 对象中。
5. 调用BasicDataSourceFactory.createDataSource(props)方法，使用props对象作为参数创建并返回一个BasicDataSource对象。
代码如下：
```
    private static BasicDataSource createDataSource() throws Exception {
        Properties props = new Properties();
        FileInputStream is = new FileInputStream("src/main/resources/db.properties");
        props.load(is);

        return BasicDataSourceFactory.createDataSource(props);
    }
```
定义用于创建表的方法。
提供一个方法，用于在数据库中创建指定的表。它接受一个连接对象作为参数，并使用预编译的方式执行创建表的 SQL 语句。具体步骤如下：
1. 定义一个私有静态方法createTable()，接受一个Connection对象作为参数，方法可能会抛出SQLException异常。
2. 定义一个字符串变量createTableSql，用于存储创建表的 SQL 语句。SQL 语句中指定表名为test_tbl1，并定义了两个列，一个是名为id的INT类型列，另一个是名为name的VARCHAR(32)类型列。
3. 使用conn.prepareStatement(createTableSql)方法创建一个PreparedStatement对象createTableStmt，该对象用于执行预编译的 SQL 语句。
4. 调用execute()方法执行 SQL 语句，用于创建表。
代码如下：
```
    private static void createTable(Connection conn) throws SQLException {
        String createTableSql = "CREATE TABLE test_tbl1 (id INT, name VARCHAR(32))";
        try (PreparedStatement createTableStmt = conn.prepareStatement(createTableSql)) {
            createTableStmt.execute();
        }
    }
```
定义用于插入数据的方法。
提供一个方法，用于向数据库中的表插入指定的数据。它接受一个连接对象作为参数，并使用预编译的方式执行插入数据的 SQL 语句。具体步骤如下：
1. 定义一个私有静态方法insertData()，接受一个Connection对象作为参数，方法可能会抛出SQLException异常。
2. 定义一个字符串变量insertDataSql，用于存储插入数据的 SQL 语句。
3. 使用conn.prepareStatement(insertDataSql)方法创建一个PreparedStatement对象insertDataStmt，该对象用于执行预编译的 SQL 语句。
4. 使用for循环向表中插入数据：
  1. 循环10次，每次循环插入一条数据。
  2. 使用setInt()方法将循环变量i的值设置为 SQL 语句中的第一个参数值。
  3. 使用setString()方法将字符串test_insert + i设置为 SQL 语句中的第二个参数值。
  4. 调用executeUpdate()方法执行 SQL 语句，用于向数据库中插入数据。
代码如下：
```
    private static void insertData(Connection conn) throws SQLException {
        String insertDataSql = "INSERT INTO test_tbl1 (id, name) VALUES (?, ?)";
        try (PreparedStatement insertDataStmt = conn.prepareStatement(insertDataSql)) {
            for (int i = 0; i < 10; i++) {
                insertDataStmt.setInt(1, i);
                insertDataStmt.setString(2, "test_insert" + i);
                insertDataStmt.executeUpdate();
            }
        }
    }
```
定义用于删除数据的方法。
提供一个方法，用于从数据库中删除满足特定条件的数据。它接受一个连接对象作为参数，并使用预编译的方式执行删除数据的 SQL 语句。具体步骤如下：
1. 定义一个私有静态方法deleteData()，接受一个Connection对象作为参数，方法可能会抛出SQLException异常。
2. 定义一个字符串变量deleteDataSql，用于存储删除数据的 SQL 语句。
3. 使用conn.prepareStatement(deleteDataSql)方法创建一个PreparedStatement对象deleteDataStmt，该对象用于执行预编译的 SQL 语句。
4. 使用setInt()方法将数字 5 设置为 SQL 语句中的参数值。
5. 调用executeUpdate()方法执行 SQL 语句，用于从数据库中删除符合条件的数据。
代码如下：
```
    private static void deleteData(Connection conn) throws SQLException {
        String deleteDataSql = "DELETE FROM test_tbl1 WHERE id < ?";
        try (PreparedStatement deleteDataStmt = conn.prepareStatement(deleteDataSql)) {
            deleteDataStmt.setInt(1, 5);
            deleteDataStmt.executeUpdate();
        }
    }
```
定义用于更新数据的方法。
提供一个方法，用于更新数据库中满足特定条件的数据。它接受一个连接对象作为参数，并使用预编译的方式执行更新数据的 SQL 语句。具体步骤如下：
1. 定义一个私有静态方法updateData()，接受一个Connection对象作为参数，方法可能会抛出SQLException异常。
2. 定义一个字符串变量updateDataSql，用于存储更新数据的 SQL 语句。
3. 使用conn.prepareStatement(updateDataSql)方法创建一个PreparedStatement对象updateDataStmt，该对象用于执行预编译的 SQL 语句。
4. 使用setString()方法将字符串test_update设置为 SQL 语句中的第一个参数值。
5. 使用setInt()方法将数字5设置为 SQL 语句中的第二个参数值。
6. 调用executeUpdate()方法执行 SQL 语句，用于更新数据库中符合条件的数据。
代码如下：
```
    private static void updateData(Connection conn) throws SQLException {
        String updateDataSql = "UPDATE test_tbl1 SET name = ? WHERE id = ?";
        try (PreparedStatement updateDataStmt = conn.prepareStatement(updateDataSql)) {
            updateDataStmt.setString(1, "test_update");
            updateDataStmt.setInt(2, 5);
            updateDataStmt.executeUpdate();
        }
    }
```
定义用于查询数据的方法。
提供一个方法，用于查询数据库中的数据并进行处理。它接受一个连接对象作为参数，并使用预编译的方式执行查询数据的 SQL 语句。具体步骤如下：
1. 定义一个私有静态方法queryData()，接受一个Connection对象作为参数，方法可能会抛出SQLException异常。
2. 定义一个字符串变量queryDataSql，用于存储查询数据的 SQL 语句。
3. 使用conn.prepareStatement(queryDataSql)方法创建一个PreparedStatement对象queryDataStmt，该对象用于执行预编译的 SQL 语句。
4. 通过queryDataStmt.executeQuery()方法执行 SQL 查询，并使用ResultSet对象rs来接收查询结果。
5. 使用while循环，通过rs.next()方法遍历查询结果集：
  1. 使用getInt()方法获取结果集中名为id的列的整数值，并将其赋值给变量id。
  2. 使用getString()方法获取结果集中名为name的列的字符串值，并将其赋值给变量name。
  3. 打印输出查询结果的id和name。
代码如下：
```
    private static void queryData(Connection conn) throws SQLException {
        String queryDataSql = "SELECT * FROM test_tbl1";
        try (PreparedStatement queryDataStmt = conn.prepareStatement(queryDataSql)) {
            try (ResultSet rs = queryDataStmt.executeQuery()) {
                while (rs.next()) {
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    System.out.println("id: " + id + ", name: " + name);
                }
            }
        }
    }
```

完整的代码展示

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>dbcp-mysql-client</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>
</project>

db.properties

jdbcUrl=jdbc:mysql://$host:$port/$database_name?useSSL=false
username=$user_name
password=$password

dataSource.cachePrepStmts=true
dataSource.prepStmtCacheSize=250
dataSource.maxLifetime=1800000
dataSource.idleTimeout=600000
dataSource.connectionTimeout=30000

Main.java

package com.example;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class Main {
    public static void main(String[] args) {
        try {
            HikariConfig config = new HikariConfig("/db.properties");
            try (HikariDataSource dataSource = new HikariDataSource(config);
                 Connection conn = dataSource.getConnection()) {
                createTable(conn);

                insertData(conn, 1, "A1");
                insertData(conn, 2, "A2");

                selectData(conn);

                updateData(conn, "test_update", 1);
                selectData(conn);

                deleteData(conn, 2);
                selectData(conn);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    private static void createTable(Connection conn) throws SQLException {
        String sql = "CREATE TABLE IF NOT EXISTS test_hikaricp (id INT, name VARCHAR(50))";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.executeUpdate();
            System.out.println("Table created successfully.");
        }
    }

    private static void insertData(Connection conn, int id, String name) throws SQLException {
        String sql = "INSERT INTO test_hikaricp (id, name) VALUES (?, ?)";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, id);
            pstmt.setString(2, name);
            pstmt.executeUpdate();
            System.out.println("Data inserted successfully.");
        }
    }

    private static void selectData(Connection conn) throws SQLException {
        String sql = "SELECT * FROM test_hikaricp";
        try (PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {
            System.out.println("User Data:");
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                System.out.println("ID: " + id + ", Name: " + name);
            }
            System.out.println();
        }
    }

    private static void updateData(Connection conn, String name, int id) throws SQLException {
        String sql = "UPDATE test_hikaricp SET name = ? WHERE id = ?";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, name);
            pstmt.setInt(2, id);
            pstmt.executeUpdate();
            System.out.println("Data updated successfully.");
        }
    }

    private static void deleteData(Connection conn, int id) throws SQLException {
        String sql = "DELETE FROM test_hikaricp WHERE id = ?";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, id);
            pstmt.executeUpdate();
            System.out.println("Data deleted successfully.");
        }
    }
}

DBCP 连接池连接 OceanBase 数据库示例程序